home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / gemini / man / cat5 / cookies.5
Encoding:
Text File  |  1994-09-22  |  14.9 KB  |  281 lines
  1. COOKIES(5)                     Dateiformate                    COOKIES(5)
  2.  
  3. N✓NA✓AM✓ME✓E
  4.      cookies - Datei mit Beschreibungen zu installierten Cookies
  5.  
  6. B✓BE✓ES✓SC✓CH✓HR✓RE✓EI✓IB✓BU✓UN✓NG✓G
  7.      Das Kommando c✓co✓oo✓ok✓ki✓ie✓e braucht zur Interpretation der in einem
  8.      Cookie eingetragen Werte eine Datei mit Beschreibungen über bekannte
  9.      Cookies.
  10.  
  11.      Die Datei soll sich in einem Verzeichnis befinden, das durch die Environ-
  12.      mentvariable 'ETCDIR' beschrieben wird (achten Sie darauf 'ETCDIR' mit 
  13.      via 'export' und nicht mittels 'setenv' ins Environment einzufügen). 
  14.      Die Struktur von 'COOKIES' wird durch folgende Regeln (EBNF) beschrieben:
  15.      
  16.      >>>---------------------------------------------------------------------<<<
  17.  
  18.           <COOKIE-FILE>
  19.  
  20.                ["COOKIE"]                    Programm-identifier
  21.  
  22.                {<cookie> | <comment>}        Liste von Cookiebeschreibungen
  23.                                              oder Kommentaren
  24.  
  25.           ----------------------------------------------------------------------
  26.           <cookie>                           ein einzelner Cookie
  27.  
  28.                "[" <string_4> "]"
  29.                [<name> | <creator> | <description> | <section> | <comment>]
  30.  
  31.                                              ein Cookie kann aus dem Namen, dem
  32.                                              Erzeuger und einer Beschreibung
  33.                                              bestehen. Kommentare dürfen na-
  34.                                              türlich auch hier nicht fehlen.
  35.                                              
  36.           ----------------------------------------------------------------------
  37.           <name>
  38.  
  39.                "NAME="<string_48>            Der volle Name eines Cookies
  40.  
  41.           ----------------------------------------------------------------------
  42.           <creator
  43.  
  44.                "CREATOR="<string_48>         Der 'Erzeuger' eines Cookies
  45.  
  46.           ----------------------------------------------------------------------
  47.           <description>
  48.  
  49.                "DESCRIPTION_"<number>"="     Hier kann eine langatmige Beschrei-
  50.                                              bung des Cookies erfolgen. Die 
  51.                                              erste Beschreibung trägt die Nr. 0,
  52.                                              alle weiteren müssen in aufstei-
  53.                                              gender Nummerierung folgen.
  54.  
  55.           ----------------------------------------------------------------------
  56.           <section>
  57.  
  58.                "<SECTION_"<number>">"        Die Beschreibung eines Abschnittes.
  59.                                              Ein Abschnitt ist dabei eine Bit-
  60.                                              gruppe innerhalb des zweiten long-
  61.                                              wertes des Cookies. z.B. der _FPU-
  62.                                              Cookie ist in 4 Abschnitte aufge-
  63.                                              teilt:
  64.                                                   12 Bits sind unbenutzt
  65.                                                   1  Bit 68040?
  66.                                                        durch Bitcodierung
  67.                                                   2  Bits 68881 oder 68882?
  68.                                                        durch Wertcodierung
  69.                                                   1  Bit SFP 004 komp. ?
  70.                                              Die erste Section trägt die Nr.
  71.                                              0, alle weiteren müssen in auf-
  72.                                              steigender Nummerierung folgen.
  73.                "CODED = "<section_coding>    Die Codierung eines Abschnittes
  74.                {(<values> | <bits> | <structure>)}
  75.                                              Die Beschreibung der Einträge
  76.  
  77.           ----------------------------------------------------------------------
  78.           <section_coding>
  79.                
  80.                <number> "," ("UNUSED" | "VALUE" | "BITS" | "STRUCTURE" |"CHAR",
  81.                              "INT" | "HEX" | "LONG" | "LONG_HEX")
  82.                                              <number> gibt die Anzahl von der
  83.                                                   Section verwendeten Bits an.
  84.                                                   Die Bits werden über alle
  85.                                                   Sections aufaddiert. Die In-
  86.                                                   terpretation startet beim
  87.                                                   höchsten Bit angefangen und
  88.                                                   ended mit Bit 0.
  89.                                              "UNSUSED": Bits sind unbenutzt
  90.                                              "VALUE": Die Section besteht aus 
  91.                                                   fixen Werten (Wertcodierung).
  92.                                              "BITS": Die Section besteht aus 
  93.                                                   einzelnen Bits (Bitcodierung),
  94.                                                   die jeweils ein bestimmte Be-
  95.                                                   deutung haben.
  96.                                              "STRUCTURE": Der komplette zweite
  97.                                                   Wert des Cookie wird als Zei-
  98.                                                   ger auf eine Struktur inter-
  99.                                                   pretiert. <number> wird igno-
  100.                                                   riert.
  101.                                              "CHAR": Die Bits dieser SECTION
  102.                                                   werden als Zeichen ausgegeben.
  103.                                              "INT": Die Bits dieser SECTION
  104.                                                   werden als Integer ausgegeben.
  105.                                              "HEX": Die Bits dieser SECTION
  106.                                                   werden als Integer in Hexa-
  107.                                                   dezimalform ausgegeben.
  108.                                              "LONG": Die Bits dieser SECTION
  109.                                                   werden als Long ausgegeben.
  110.                                              "LONG_HEX": Die Bits dieser SECTION
  111.                                                   werden als Long in Hexade-
  112.                                                   zimalform ausgegeben.
  113.  
  114.           ----------------------------------------------------------------------
  115.           <structure>
  116.  
  117.                {"<SECTION_" <number> "_" <number> ">"
  118.  
  119.                                              Die Beschreibung eines Elementes.
  120.  
  121.                 {"ELEMENT =" <string_48> "," <type> "," ("UNUSED"|
  122.                                                          "VALUE" |
  123.                                                          "BITS" |
  124.                                                          "CHAR" |
  125.                                                          "CHAR_POINTER" |
  126.                                                          "INT" |
  127.                                                          "INT_POINTER" |
  128.                                                          "HEX" |
  129.                                                          "HEX_POINTER"|
  130.                                                          "LONG" |
  131.                                                          "LONG_POINTER" |
  132.                                                          "LONG_HEX" |
  133.                                                          "LONG_HEX_POINTER" |
  134.                                                          "POINTER") "," <number>
  135.                                                          
  136.                                              <string_48> Name des Elementes
  137.                                              <type> Es kann entweder ein ein-
  138.                                                   facher Typ oder ein Feld mit
  139.                                                   einfachen Typen ausgegeben
  140.                                                   werden.
  141.                                              <number>: ist der <type> = "ARRAY"
  142.                                                   dann gibt <number> die Anzahl
  143.                                                   der Elemente im Feld wieder.
  144.                                                   Bei "SIMPLE" wird <number> 
  145.                                                   nur dann herangezogen, wenn
  146.                                                   "VALUE"s aktiv ist. Dann kann
  147.                                                   <number> 2 oder 4 (Byte) sein.
  148.                                                   Damit lassen sich dann int
  149.                                                   oder long "VALUE"s unterschei-
  150.                                                   den.
  151.  
  152.                   {(<values> | <bits>)}
  153.                 }
  154.                }
  155.                
  156.           ----------------------------------------------------------------------
  157.           <values>
  158.  
  159.                [{"VALUE_" <number> " = " <number> "," <string_48>} | 
  160.                  "DEFAULT = " <string_48>]
  161.  
  162.                                              Der erste "VALUE" trägt die Nr.
  163.                                              0, alle weiteren müssen in auf-
  164.                                              steigender Reihe folgen.
  165.                                              Die zweite <number> gibt den Wert
  166.                                              an, der als Prüfbedingung für den
  167.                                              Vergleich und die anschließende
  168.                                              Ausgabe von <string_48> dient. Der
  169.                                              Wert kann int oder long sein.
  170.                                              Wenn keiner der "VALUE"s trifft, 
  171.                                              dann versucht das Programm den
  172.                                              "DEFAULT"-Wert zufinden, der nur
  173.                                              eine Erläuterung (<string_48>) als
  174.                                              Parameter trägt.
  175.                                                             
  176.           ----------------------------------------------------------------------
  177.           <bits>
  178.  
  179.                ["BIT_" <number> " = <string_48>"," <string_48>]
  180.  
  181.                                              Hiermit werden einzelne Bits ge-
  182.                                              prüft. Die <number>, die zur Spezi-
  183.                                              fizierung des Bits angegeben wird,
  184.                                              darf zwischen 0 und 31 liegen.
  185.                                              Der erste <string_48> gibt die Be-
  186.                                              deutung des Bits wieder wenn es 
  187.                                              gesetzt ist, der zweite wenn es 
  188.                                              nicht gesetzt ist. Meist unter-
  189.                                              bleibt der zweite Wert, weil nicht
  190.                                              gesetzte Bits selten eine Bedeu-
  191.                                              tung haben.
  192.                
  193.           ----------------------------------------------------------------------
  194.           <type>
  195.  
  196.                ("SIMPLE" | "ARRAY")          "SIMPLE": Ein einfacher Datentyp
  197.                                              "ARRAY": Ein Feld einfacher Daten-
  198.                                                   typen
  199.                
  200.           ----------------------------------------------------------------------
  201.           <number>
  202.  
  203.                {"0" | ... | "9"}             Normale Zahlen
  204.  
  205.           ----------------------------------------------------------------------
  206.           <string_4>
  207.           
  208.                Alle Zeichen mit Ausnahme des '"'-Zeichens
  209.                
  210.                                              Anzahl der Wiederholungen auf 4
  211.                                              beschränkt
  212.  
  213.           ----------------------------------------------------------------------
  214.           <string_48>
  215.           
  216.                Alle Zeichen mit Ausnahme des '"'-Zeichens
  217.                
  218.                                              Anzahl der Wiederholungen auf 48
  219.                                              beschränkt
  220.  
  221.      >>>---------------------------------------------------------------------<<<
  222.  
  223.      Beispiel:
  224.      
  225.      Check Open Files legt einen Cookie namens "OFLS" an, dessen zweiter long-
  226.      Wert auf eine Struktur im Speicher zeigt, die in "C" wie folgt notiert 
  227.      wird:
  228.  
  229.           struct ofls_cookie
  230.           {
  231.              long  product;             /* 'OFLS' (0x4F464C53)    */
  232.              unsigned short version;    /* z.B. 0x0103 für V 1.03 */
  233.              signed short drives[32];   /* Infos für 32 Laufwerke */
  234.              signed short reserved[32]; /* Für evt. Erweiterungen */
  235.           };
  236.  
  237.      Eine Umsetzung der obigen Beschreibung in die Syntax von COOKIES sieht wie
  238.      folgt aus:
  239.  
  240.           [OFLS]
  241.           NAME = "Check Open Files";
  242.           CREATOR = "Hans-Jürgen Richstein (Standardcookie)";
  243.           DESCRIPTION_0 = "Merkt sich alle auf einem Laufwerk offenen"
  244.           DESCRIPTION_1 = "Dateien, so daß Programme, die auf der FAT"
  245.           DESCRIPTION_2 = "operieren (z.B. KOBOLD, Diskus) keinen Daten-"
  246.           DESCRIPTION_3 = "verlust forcieren. Eine '-1' als Status heißt,"
  247.           DESCRIPTION_4 = "daß das Laufwerk für Dateioperationen gesperrt"
  248.           DESCRIPTION_5 = "ist, weil eine FAT-orientierte Anwendung auf"
  249.           DESCRIPTION_6 = "dem Laufwerk arbeitet."
  250.  
  251.           <SECTION_0>
  252.           CODED = 32,STRUCTURE
  253.           <SECTION_0_0>
  254.           ELEMENT = "Produkt:   ",SIMPLE,VALUE,4
  255.           VALUE_0 = 0x4F464C53,"CHK_OFLS.PRG (Kaktus)";
  256.           DEFAULT = "Unbekannt";
  257.           <SECTION_0_1>
  258.           ELEMENT = "Version:   ",SIMPLE,HEX,0
  259.           <SECTION_0_2>
  260.           ELEMENT = "Status A-P:  ",ARRAY,INT,16
  261.           <SECTION_0_3>
  262.           ELEMENT = "Status Q-...:",ARRAY,INT,16
  263.  
  264.      Um weitere Beispiele kennenzulernen schauen Sie bitte in die mitgelieferte 
  265.      "COOKIES"-Datei. Neben dem schon angesprochenen "OFLS"-Cookie haben die
  266.      Cookies "_FDC" und "FSMC" besonderen Beispielcharakter.
  267.  
  268.  
  269. E✓ER✓RW✓WE✓EI✓IT✓TE✓ER✓RU✓UN✓NG✓GE✓EN✓N
  270.      Dürfen vom Benutzer in freier Eigenverantwortung vorgenommen werden. Sicher-
  271.      lich wäre es sinnvoll, solche Erweiterungen dem Autor mitzuteilen, damit so 
  272.      auf Dauer eine umfangreiche Sammlung entsteht. Besonders interessant sind 
  273.      hier Beschreibungen für Strukturen, auf die ein Cookie zeigt kann.
  274.  
  275. D✓DA✓AT✓TE✓EI✓IE✓EN✓N
  276.      $ETCDIR\cookies
  277.      .\cookies
  278.           An diesen Orten (und in dem Verzeichnis, in dem cookie.ttp 
  279.           selbst sich befindet) wird nach der Cookies-Datei gesucht.
  280.  
  281.